// API 服务配置
const API_BASE_URL = 'http://localhost:8080'

// 历史记录接口
export interface HistoryQuery {
  sessionId: string
  count?: number
}

// 发送消息接口
export interface SendMessageQuery {
  message: string
  sessionId: string
}

export interface HistoryResponse {
  // 根据实际API返回结构定义
  data: any[]
  total?: number
  sessionId: string
}

// 解析ChatMessage字符串格式的公共函数
function parseChatMessage(data: string) {
  const match = data.match(/ChatMessage\{([^}]+)\}/)
  if (!match) return null
  
  const content = match[1]
  const chatMessage: any = {}
  
  // 更精确的解析键值对，处理包含逗号和引号的值
  const regex = /(\w+)=('([^']*)'|([^,]*))/g
  let regexMatch
  
  while ((regexMatch = regex.exec(content)) !== null) {
    const key = regexMatch[1].trim()
    let value: string | null
    
    if (regexMatch[3] !== undefined) {
      // 引号包围的值
      value = regexMatch[3]
    } else {
      // 非引号包围的值
      value = regexMatch[4].trim()
    }
    
    // 处理null值
    if (value === 'null' || value === '') {
      value = null
    }
    
    chatMessage[key] = value
  }
  
  console.log('解析ChatMessage结果:', chatMessage)
  return chatMessage
}

// 发送消息API - 使用与queryHistory相同的数据处理逻辑
export async function sendMessage(
  params: SendMessageQuery, 
  onMessage?: (content: string) => void,
  onComplete?: (fullContent: string) => void,
  onError?: (error: string) => void
): Promise<void> {
  const { message, sessionId } = params
  
  const url = `http://localhost:8080/api/sports-ai/chat/stream?message=${encodeURIComponent(message)}&sessionId=${encodeURIComponent(sessionId)}`
  
  try {
    console.log('流式发送消息:', url)
    
    const response = await fetch(url, {
      method: 'GET',
      redirect: 'follow' as RequestRedirect
    })
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }
    
    // 流式读取响应
    const reader = response.body?.getReader()
    const decoder = new TextDecoder()
    let accumulatedContent = ''
    let thinkingContent = ''  // 累积思考过程内容
    
    if (!reader) {
      throw new Error('无法获取响应流')
    }
    
    // 流式处理函数
    async function processMessageStream(): Promise<void> {
      const { done, value } = await reader!.read()
      
      if (done) {
        // 流式结束，组合思考内容和普通内容
        let finalContent = ''
        if (thinkingContent.trim()) {
          finalContent += `<thinking>${thinkingContent}</thinking>`
        }
        if (accumulatedContent.trim()) {
          finalContent += accumulatedContent
        }
        
        console.log('消息流式读取完成')
        console.log('思考内容长度:', thinkingContent.length)
        console.log('普通内容长度:', accumulatedContent.length)
        
        onComplete?.(finalContent || accumulatedContent)
        return
      }
      
      // 解码数据
      const chunk = decoder.decode(value, { stream: true })
      
      // 解析ChatMessage格式的流式数据
      if (chunk.includes('ChatMessage{')) {
        const lines = chunk.split('\n')
        for (const line of lines) {
          if (line.includes('ChatMessage{')) {
            // 提取ChatMessage数据（可能有data:前缀）
            let data = line.trim()
            if (data.startsWith('data:')) {
              data = data.substring(5).trim()
            }
            
            try {
              // 解析ChatMessage格式
              const chatMessage = parseChatMessage(data)
              if (chatMessage) {
                // 处理思考内容
                if (chatMessage.reasoningContent && chatMessage.reasoningContent !== 'null' && chatMessage.reasoningContent !== null && chatMessage.reasoningContent.trim() !== '') {
                  onMessage?.(`<think>${chatMessage.reasoningContent}</think>`)
                }
                
                // 处理回答内容
                if (chatMessage.content && chatMessage.content !== 'null' && chatMessage.content !== null && chatMessage.content.trim() !== '') {
                  onMessage?.(chatMessage.content)
                }
              }
            } catch (e) {
              console.warn('解析ChatMessage失败:', data, e)
              // 如果解析失败，不要显示原始数据
            }
          }
        }
      } else if (chunk.includes('data:')) {
        // 处理标准SSE格式 - 与queryHistory保持完全一致
        const lines = chunk.split('\n')
        for (const line of lines) {
          // 处理 data: 和 data: 两种格式
          if (line.startsWith('data: ') || line.startsWith('data:')) {
            let data = ''
            if (line.startsWith('data: ')) {
              data = line.substring(6).trim()
            } else if (line.startsWith('data:')) {
              data = line.substring(5).trim()
            }
            
            if (data === '[DONE]') {
              onComplete?.(accumulatedContent)
              return
            }
            
            try {
              const parsed = JSON.parse(data)
              if (parsed.content) {
                // 根据type字段分别累积不同类型的内容
                if (parsed.type === 'thinking') {
                  // AI思考过程内容
                  thinkingContent += parsed.content
                  console.log('累积AI思考内容:', parsed.content)
                  // 传递思考内容，添加特殊标记
                  onMessage?.(`[THINKING]${parsed.content}`)
                } else if (parsed.type === 'reasoning') {
                  // 回答过程内容
                  accumulatedContent += parsed.content
                  console.log('累积回答内容:', parsed.content)
                  // 传递回答内容，添加特殊标记
                  onMessage?.(`[REASONING]${parsed.content}`)
                } else {
                  // 其他类型内容（没有type字段或其他类型）
                  accumulatedContent += parsed.content
                  console.log('累积其他内容:', parsed.content)
                  // 传递普通内容
                  onMessage?.(parsed.content)
                }
              }
            } catch (e) {
              // 解析失败时不显示原始数据，只记录到控制台
              console.warn('解析消息JSON失败:', data, e)
              // 不要将解析失败的数据传递给界面
            }
          }
        }
      } else {
        // 普通文本数据 - 只有在确实是文本内容时才处理
        if (chunk.trim() && !chunk.includes('{') && !chunk.includes('}')) {
          accumulatedContent += chunk
          onMessage?.(chunk)
        } else {
          console.warn('忽略非文本数据块:', chunk.substring(0, 50))
        }
      }
      
      // 继续读取
      return processMessageStream()
    }
    
    await processMessageStream()
    
  } catch (error) {
    console.error('流式发送消息时出错:', error)
    const errorMessage = error instanceof Error ? error.message : String(error)
    onError?.(errorMessage)
    throw error
  }
}

// 历史记录查询API
export async function queryHistory(
  params: HistoryQuery, 
  onMessage?: (content: string) => void,
  onComplete?: (fullContent: string) => void,
  onError?: (error: string) => void
): Promise<void> {
  const { sessionId, count = 5 } = params
  
  const url = `http://localhost:8080/api/sports-ai/chat/stream?message='请你预测26号 国际米兰VS河床 比赛 具体数据以表格形式呈现'&sessionId=${encodeURIComponent(sessionId)}`
  
  try {
    console.log('流式请求历史记录:', url)
    
    const response = await fetch(url, {
      method: 'GET',
      redirect: 'follow' as RequestRedirect
    })
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }
    
    // 流式读取响应
    const reader = response.body?.getReader()
    const decoder = new TextDecoder()
    let accumulatedContent = ''
    let thinkingContent = ''  // 新增：累积思考过程内容
    
    if (!reader) {
      throw new Error('无法获取响应流')
    }
    
    // 流式处理函数
    async function processHistoryStream(): Promise<void> {
      const { done, value } = await reader!.read()
      
      if (done) {
        // 流式结束，组合思考内容和普通内容
        let finalContent = ''
        if (thinkingContent.trim()) {
          finalContent += `<thinking>${thinkingContent}</thinking>`
        }
        if (accumulatedContent.trim()) {
          finalContent += accumulatedContent
        }
        
        console.log('历史记录流式读取完成')
        console.log('思考内容长度:', thinkingContent.length)
        console.log('普通内容长度:', accumulatedContent.length)
        
        onComplete?.(finalContent || accumulatedContent)
        return
      }
      
      // 解码数据
      const chunk = decoder.decode(value, { stream: true })
      
             // 解析ChatMessage格式的流式数据
       if (chunk.includes('ChatMessage{')) {
         const lines = chunk.split('\n')
         for (const line of lines) {
           if (line.includes('ChatMessage{')) {
             // 提取ChatMessage数据（可能有data:前缀）
             let data = line.trim()
             if (data.startsWith('data:')) {
               data = data.substring(5).trim()
             }
             
             try {
               // 解析ChatMessage格式
               const chatMessage = parseChatMessage(data)
               if (chatMessage) {
                 // 处理思考内容
                 if (chatMessage.reasoningContent && chatMessage.reasoningContent !== 'null' && chatMessage.reasoningContent !== null && chatMessage.reasoningContent.trim() !== '') {
                   onMessage?.(`<think>${chatMessage.reasoningContent}</think>`)
                 }
                 
                 // 处理回答内容
                 if (chatMessage.content && chatMessage.content !== 'null' && chatMessage.content !== null && chatMessage.content.trim() !== '') {
                   onMessage?.(chatMessage.content)
                 }
               }
             } catch (e) {
               console.warn('解析ChatMessage失败:', data, e)
               // 如果解析失败，不要显示原始数据
             }
           }
         }
       } else if (chunk.includes('data:')) {
         // 处理标准SSE格式 - 和发送按钮保持完全一致
         const lines = chunk.split('\n')
         for (const line of lines) {
           // 处理 data: 和 data: 两种格式
           if (line.startsWith('data: ') || line.startsWith('data:')) {
             let data = ''
             if (line.startsWith('data: ')) {
               data = line.substring(6).trim()
             } else if (line.startsWith('data:')) {
               data = line.substring(5).trim()
             }
             
             if (data === '[DONE]') {
               onComplete?.(accumulatedContent)
               return
             }
             
             try {
               const parsed = JSON.parse(data)
               if (parsed.content) {
                 // 根据type字段分别累积不同类型的内容
                 if (parsed.type === 'thinking') {
                   // AI思考过程内容
                   thinkingContent += parsed.content
                   console.log('累积AI思考内容:', parsed.content)
                   // 传递思考内容，添加特殊标记
                   onMessage?.(`[THINKING]${parsed.content}`)
                 } else if (parsed.type === 'reasoning') {
                   // 回答过程内容
                   accumulatedContent += parsed.content
                   console.log('累积回答内容:', parsed.content)
                   // 传递回答内容，添加特殊标记
                   onMessage?.(`[REASONING]${parsed.content}`)
                 } else {
                   // 其他类型内容（没有type字段或其他类型）
                   accumulatedContent += parsed.content
                   console.log('累积其他内容:', parsed.content)
                   // 传递普通内容
                   onMessage?.(parsed.content)
                 }
               }
             } catch (e) {
               // 解析失败时不显示原始数据，只记录到控制台
               console.warn('解析历史记录JSON失败:', data, e)
               // 不要将解析失败的数据传递给界面
             }
           }
         }
       } else {
         // 普通文本数据 - 只有在确实是文本内容时才处理
         if (chunk.trim() && !chunk.includes('{') && !chunk.includes('}')) {
           accumulatedContent += chunk
           onMessage?.(chunk)
         } else {
           console.warn('忽略非文本数据块:', chunk.substring(0, 50))
         }
       }
      
      // 继续读取
      return processHistoryStream()
    }
    
    await processHistoryStream()
    
  } catch (error) {
    console.error('流式查询历史记录时出错:', error)
    const errorMessage = error instanceof Error ? error.message : String(error)
    onError?.(errorMessage)
    throw error
  }
}

// 其他可能需要的API函数可以在这里添加
export default {
  queryHistory,
  sendMessage
} 